/** 引入中国全省市区的数据 **/
import {
  codeToText
} from "element-china-area-data";
/**
 * 判断字符串不为空
 * @param str
 * @returns {boolean}
 */
export function strIsNotEmpty(str) {
  if(typeof str =='boolean'){
    return true
  }
  if(typeof str =='number'){
    return typeof !Number.isNaN(str) && Number.isFinite(str);
  }
  if (str != undefined && str != 'undefined' && str != null && str != '') {
    return true
  }
  return false
}

/**
 * 判断字符串为空
 * @param str
 * @returns {boolean}
 */
export function strIsEmpty(str) {
  return !strIsNotEmpty(str);
}
/**
 * 判断对象是否为空
 * @param str
 * @returns {boolean}
 */
export function objectIsEmpty(obj) {
  return Object.keys(obj).length === 0;
}

/**
 * 特殊字符处理
 * @param content
 * @returns {*}
 */
export function escapeDeal(content){
  if(strIsNotEmpty(content)){
    content = content.replace(/&lt;/gi, '<'); //小于符号处理
    content = content.replace(/&gt;/gi, '>'); //大于符号处理
    content = content.replace(/&apos;/gi, '\''); //单引号处理
    content = content.replace(/&quot;/gi, '\"'); //双引号处理
    content = content.replace(/&amp;/gi, '&'); //&号处理
  }
  return content
}

/**
 * 将字符串转boolean
 * @param obj
 * @returns {boolean}
 */
export function dealBoolean(obj){
  if(obj==true || obj=='true' || obj=='TRUE'){
    return true;
  }
  return false;
}

/**
 * 下拉列表翻译
 **/
export function translatorFormatter(row, item){
  let showTxt = ''
  switch (item.htmlType) {
    case 'date'://日期控件
      showTxt = this.parseTime(row[item.columnName], '{y}-{m}-{d}')
      break
    case 'datetime'://日期时间控件
      showTxt = this.parseTime(row[item.columnName], '{y}-{m}-{d} {hh}:{mi}:{ss}')
      break
    case 'password'://密码控件
      showTxt = '******'
      break
    case 'radio'://单选框
      showTxt = this.selectDictLabel(item.dictItems, row[item.columnName])
      break
    case 'input'://文本框
    case 'textarea'://文本域
    case 'number'://数字类型
    case 'editor'://富文本控件
      let _showTxt = ''
      if(this.strIsNotEmpty(item['dataDesensitizeLogic'])){
        //当前存在信息需要脱敏处理
        _showTxt = evalDataDesensitizeLogic(row[item.columnName],item['dataDesensitizeLogic'])
      }
      showTxt = _showTxt || row[item.columnName]
      break
    case 'select'://下拉框
    case 'allowCreateSelect'://下拉框
    case 'multipleSelect'://多选下拉框
    case 'multipleallowCreateSelect'://多选下拉框
    case 'checkbox'://复选框
      showTxt = this.selectDictLabels(item.dictItems, row[item.columnName], ',')
      break
    case 'CascaderArea': // 级联选择
      try{
        let content = "";
        let data=row[item.columnName];
        if (typeof data == 'string') {
          data = data.split(',')
        }
        data.map((item) => (content += codeToText[item] + "/")); //将级联值拼接一起
        if(this.strIsNotEmpty(content)){
          content = content.substring(0,content.lastIndexOf("/"))
        }
        showTxt = content
      }catch (e) {
        showTxt = row[item.columnName]
      }
      break
    default:
      showTxt = row[item.columnName]
      break
  }
  return showTxt
}

/** 数据脱敏处理 **/
export function evalDataDesensitizeLogic(info,desensitizeLogic) {
  if (desensitizeLogic) {
    /** 特殊字符处理 **/
    desensitizeLogic = escapeDeal(desensitizeLogic);
    // 创建函数对象
    const func = new Function("info",desensitizeLogic);
    return func.call(this,info);
  }
  return info;
}

/** 生成唯一标识 **/
export function generateNumTag() {
  return parseInt(Math.random() * (999999999 - 100000000) + 10)
}

/** 随机生成uuid **/
export function generateUuid() {
  var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
  var uuid = [],
    i;
  var len = 32
  if (len) {
    for (i = 0; i < len; i++) uuid[i] = chars[0 | Math.random() * chars.length];
  } else {
    var r;
    for (i = 0; i < 32; i++) {
      if (!uuid[i]) {
        r = 0 | Math.random() * 16;
        uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
      }
    }
  }
  return uuid.join('');
}

/**
 * 驼峰命名转换
 * @param str
 * @returns {*}
 */
export function toCamelCase(str) {
  if(str==undefined || str==null || str==''){
    return str
  }
  let reg=/_+(\w)/g;
  let result=str.replace(reg,function(){
    if(arguments[2])return (arguments[1]).toUpperCase();
    else return arguments[0];
  });
  return result;
}

/**
 * 成功消息提示
 * @param msg
 */
export function msgSuccess(msg) {
  this.$message({ showClose: true, message: msg, type: 'success' })
}

/**
 * 失败消息提示
 * @param msg
 */
export function msgError(msg) {
  this.$message({ showClose: true, message: msg, type: 'error' })
}


/**
 * 根据指定的开始字符与结束字符，截取字符串中的内容
 */
export function substringBetween(str,start,end) {
  if(!strIsNotEmpty(str) || !strIsNotEmpty(start) || !strIsNotEmpty(start)){
    return str
  }
  let sIndex=str.indexOf(start);
  if(sIndex>-1){
    let eIndex=str.indexOf(end,sIndex+start.length)
    if(eIndex>-1){
      return str.substring(sIndex+start.length,eIndex)
    }
  }
  return str
}

/**
 * 判断对象是否存在于数组中
 * @param arr
 * @param obj
 * @returns {*}
 */
export function objectExistsInArray(arr, obj) {
  return arr.some(element => JSON.stringify(element) === JSON.stringify(obj));
}


/**
 * 获取集合、对象中指定的属性值
 * @param data
 * @param property
 * @returns {*[]}
 */
export function getPropertyValues(data, property) {
  const values = [];
  function traverse(obj) {
    if (obj[property]) {
      values.push(obj[property]);
    }
    if (obj.children && Array.isArray(obj.children)) {
      obj.children.forEach(child => {
        traverse(child);
      });
    }
  }
  if (Array.isArray(data)) {
    data.forEach(item => {
      traverse(item);
    });
  } else {
    traverse(data);
  }
  return values;
}

/**
 * 判断集合或集合中子对象是否包含指定值
 * @param collection
 * @param propertyName
 * @returns {boolean}
 */
export function hasPropertyInCollection(collection, propertyName, propertyValue) {
  function checkObject(obj) {
    if (obj[propertyName]==propertyValue) {
      return true;
    }
    if (obj.children && Array.isArray(obj.children)) {
      for (let child of obj.children) {
        if (checkObject(child)) {
          return true;
        }
      }
    }
    return false;
  }

  for (let item of collection) {
    if (checkObject(item)) {
      return true;
    }
  }
  return false;
}

/**
 * 将字母下划线转驼峰
 * @param str
 * @returns {*}
 */
export function underscoreToCamelCase(str) {
  return str.replace(/_([a-z])/g, (match, p1) => p1.toUpperCase());
}

/**
 * 驼峰命名转下划线小写格式
 * @param camelStr
 * @returns {*}
 */
export function camelToSnake(camelStr) {
  if(camelStr == null || camelStr == undefined){
    return ""
  }
  // 在大写字母前插入下划线，然后转为小写
  return camelStr.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`)
    // 处理首字母大写的情况（如 PascalCase）
    .replace(/^_/, '');
}
/**
 * 字符串转时间
 * @param str
 * @param format
 * @returns {Date}
 */
export function parseDate(str, format) {
  const [datePart, timePart] = str.split(' ');
  const [year, month, day] = datePart.split(format).map(Number);
  const [hour = 0, minute = 0, second = 0] = (timePart || '').split(':').map(Number);
  // 注意：月份从0开始，所以要减1
  return new Date(year, month - 1, day, hour, minute, second);
}

/**
 * 格式化时间
 * @param date
 * @param format
 * @returns {*}
 */
export function formatDate(date, format) {
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const day = String(date.getDate()).padStart(2, '0');
  const hour = String(date.getHours()).padStart(2, '0');
  const minute = String(date.getMinutes()).padStart(2, '0');
  const second = String(date.getSeconds()).padStart(2, '0');

  return format
    .replace('YYYY', year)
    .replace('MM', month)
    .replace('DD', day)
    .replace('HH', hour)
    .replace('mm', minute)
    .replace('ss', second);
}
